package services

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"strings"
)

// TemplateService 模板服务
type TemplateService struct {
	templatesDir    string
	configService   *TemplateConfigService
	templatesCache  []Template
	cacheValid      bool
}

// NewTemplateService 创建模板服务
func NewTemplateService() *TemplateService {
	// 开发环境使用项目根目录的 templates 文件夹
	// 生产环境使用用户目录
	templatesDir := "templates"
	if _, err := os.Stat(templatesDir); os.IsNotExist(err) {
		// 如果 templates 目录不存在，使用用户目录
		homeDir, _ := os.UserHomeDir()
		templatesDir = filepath.Join(homeDir, ".batch-doc-generator", "templates")
	}
	os.MkdirAll(templatesDir, 0755)
	
	configService := NewTemplateConfigService(templatesDir)
	
	return &TemplateService{
		templatesDir:  templatesDir,
		configService: configService,
		cacheValid:    false,
	}
}

// Template 模板结构
type Template struct {
	ID          string   `json:"id"`
	Name        string   `json:"name"`
	Type        string   `json:"type"`        // "text" 或 "docx"
	Content     string   `json:"content"`    // 文本内容或 docx 文件路径
	FilePath    string   `json:"filePath"`   // docx 文件路径（仅当 type 为 docx 时）
	Variables   []string `json:"variables"`
	Category    string   `json:"category,omitempty"`
	Description string   `json:"description,omitempty"`
	Scene       string   `json:"scene,omitempty"`
	CreatedAt   string   `json:"createdAt"`
	UpdatedAt   string   `json:"updatedAt"`
}

// SaveTemplate 保存模板
func (s *TemplateService) SaveTemplate(template Template) error {
	templatePath := filepath.Join(s.templatesDir, template.ID+".json")
	data, err := json.MarshalIndent(template, "", "  ")
	if err != nil {
		return err
	}
	return os.WriteFile(templatePath, data, 0644)
}

// SaveDocxTemplate 保存 DOCX 模板文件
func (s *TemplateService) SaveDocxTemplate(templateID string, docxData []byte) (string, error) {
	docxPath := filepath.Join(s.templatesDir, templateID+".docx")
	err := os.WriteFile(docxPath, docxData, 0644)
	if err != nil {
		return "", err
	}
	return docxPath, nil
}

// LoadTemplate 加载模板（从 templates.json 和实际文件）
func (s *TemplateService) LoadTemplate(id string) (*Template, error) {
	// 从配置中获取模板信息
	info, err := s.configService.GetTemplateInfo(id)
	if err != nil {
		return nil, err
	}
	
	// 检查 DOCX 文件是否存在
	docxPath := filepath.Join(s.templatesDir, info.FileName)
	if _, err := os.Stat(docxPath); os.IsNotExist(err) {
		return nil, fmt.Errorf("模板文件不存在: %s", info.FileName)
	}
	
	// 提取变量
	docxService := NewDocxService()
	variables, err := docxService.ExtractVariablesFromDocx(docxPath)
	if err != nil {
		variables = []string{}
	}
	if variables == nil {
		variables = []string{}
	}
	
	template := &Template{
		ID:          info.ID,
		Name:        info.Name,
		Type:        "docx",
		FilePath:    docxPath,
		Variables:   variables,
		Category:    info.Category,
		Description: info.Description,
		Scene:       info.Scene,
		CreatedAt:   "",
		UpdatedAt:   "",
	}
	
	return template, nil
}

// ListTemplates 列出所有模板（使用缓存）
func (s *TemplateService) ListTemplates() ([]Template, error) {
	// 如果缓存有效，直接返回
	if s.cacheValid && len(s.templatesCache) > 0 {
		return s.templatesCache, nil
	}
	
	// 从 templates.json 读取配置
	config, err := s.configService.LoadConfig()
	if err != nil {
		return []Template{}, err
	}
	
	var templates []Template
	for _, info := range config.Templates {
		// 检查 DOCX 文件是否存在
		docxPath := filepath.Join(s.templatesDir, info.FileName)
		if _, err := os.Stat(docxPath); os.IsNotExist(err) {
			continue
		}
		
		// 提取变量
		docxService := NewDocxService()
		variables, err := docxService.ExtractVariablesFromDocx(docxPath)
		if err != nil {
			variables = []string{}
		}
		if variables == nil {
			variables = []string{}
		}
		
		template := Template{
			ID:          info.ID,
			Name:        info.Name,
			Type:        "docx",
			FilePath:    docxPath,
			Variables:   variables,
			Category:    info.Category,
			Description: info.Description,
			Scene:       info.Scene,
			CreatedAt:   "",
			UpdatedAt:   "",
		}
		
		templates = append(templates, template)
	}
	
	// 更新缓存
	s.templatesCache = templates
	s.cacheValid = true
	
	return templates, nil
}

// RefreshCache 刷新缓存
func (s *TemplateService) RefreshCache() {
	s.cacheValid = false
	s.templatesCache = nil
}

// DeleteTemplate 删除模板（从配置中删除）
func (s *TemplateService) DeleteTemplate(id string) error {
	// 从配置中删除
	err := s.configService.RemoveTemplateInfo(id)
	if err != nil {
		return err
	}
	
	// 刷新缓存
	s.RefreshCache()
	
	return nil
}

// FillTemplate 填充模板（返回文件路径，对于 docx 类型）
func (s *TemplateService) FillTemplate(templateID string, data map[string]string, outputPath string) (string, error) {
	template, err := s.LoadTemplate(templateID)
	if err != nil {
		return "", err
	}

	if template.Type == "docx" {
		// 填充 DOCX 模板
		docxService := NewDocxService()
		err := docxService.FillDocx(template.FilePath, data, outputPath)
		if err != nil {
			return "", err
		}
		return outputPath, nil
	} else {
		// 填充文本模板
		result := template.Content
		for key, value := range data {
			placeholder := "{{" + key + "}}"
			result = strings.ReplaceAll(result, placeholder, value)
		}
		// 保存文本文件
		err := os.WriteFile(outputPath, []byte(result), 0644)
		if err != nil {
			return "", err
		}
		return outputPath, nil
	}
}

// ImportTemplatesFromFolder 从文件夹导入模板（同步到 templates.json）
func (s *TemplateService) ImportTemplatesFromFolder(folderPath string) ([]Template, error) {
	var templates []Template
	
	// 确保文件夹存在
	if _, err := os.Stat(folderPath); os.IsNotExist(err) {
		return templates, fmt.Errorf("文件夹不存在: %s", folderPath)
	}
	
	// 扫描文件夹中的所有 DOCX 文件
	err := filepath.Walk(folderPath, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		
		// 只处理 DOCX 文件
		if !info.IsDir() && strings.ToLower(filepath.Ext(path)) == ".docx" {
			fileName := info.Name()
			templateID := strings.TrimSuffix(fileName, filepath.Ext(fileName))
			
			// 复制文件到模板目录
			docxData, err := os.ReadFile(path)
			if err != nil {
				return err
			}
			
			docxPath := filepath.Join(s.templatesDir, fileName)
			err = os.WriteFile(docxPath, docxData, 0644)
			if err != nil {
				return err
			}
			
			// 提取变量
			docxService := NewDocxService()
			variables, err := docxService.ExtractVariablesFromDocx(docxPath)
			if err != nil {
				variables = []string{}
			}
			if variables == nil {
				variables = []string{}
			}
			
			// 检查配置中是否已存在
			existingInfo, _ := s.configService.GetTemplateInfo(templateID)
			if existingInfo == nil {
				// 添加到配置
				templateInfo := TemplateInfo{
					ID:          templateID,
					Name:        templateID,
					Category:    "其他",
					Description: "",
					Scene:       "",
					FileName:    fileName,
					IsBuiltIn:   false,
				}
				s.configService.AddTemplateInfo(templateInfo)
			}
			
			// 创建模板对象
			template := Template{
				ID:        templateID,
				Name:      templateID,
				Type:      "docx",
				FilePath:  docxPath,
				Variables: variables,
			}
			
			templates = append(templates, template)
		}
		
		return nil
	})
	
	// 刷新缓存
	s.RefreshCache()
	
	return templates, err
}

// GetDefaultTemplatesFolder 获取默认模板文件夹路径
func (s *TemplateService) GetDefaultTemplatesFolder() string {
	// 开发环境使用项目根目录的 templates
	if _, err := os.Stat("templates"); err == nil {
		absPath, _ := filepath.Abs("templates")
		return absPath
	}
	
	// 否则返回用户目录
	homeDir, _ := os.UserHomeDir()
	return filepath.Join(homeDir, ".batch-doc-generator", "templates")
}

